home *** CD-ROM | disk | FTP | other *** search
/ Champak 52 / Volume 52 - JOGO DISK .iso / Games / rodenttreejump.swf / scripts / __Packages / MochiAd.as
Text File  |  2007-09-27  |  34KB  |  741 lines

  1. var ┬º\x01┬º = 545;
  2. loop0:
  3. while(true)
  4. {
  5.    if(eval("\x01") == 545)
  6.    {
  7.       set("\x01",eval("\x01") + 278);
  8.       ┬º┬ºpush(true);
  9.       continue;
  10.       set("\x01",eval("\x01") - 885);
  11.       ┬º┬ºpush(true);
  12.    }
  13.    if(eval("\x01") == 853)
  14.    {
  15.       set("\x01",eval("\x01") - 48);
  16.       break;
  17.    }
  18.    if(eval("\x01") == 940)
  19.    {
  20.       set("\x01",eval("\x01") - 140);
  21.       break;
  22.    }
  23.    if(eval("\x01") != 89)
  24.    {
  25.       if(eval("\x01") == 895)
  26.       {
  27.          set("\x01",eval("\x01") - 814);
  28.          ┬º┬ºpush(true);
  29.          continue;
  30.       }
  31.       if(eval("\x01") == 404)
  32.       {
  33.          set("\x01",eval("\x01") + 453);
  34.          if(┬º┬ºpop())
  35.          {
  36.             set("\x01",eval("\x01") + 38);
  37.          }
  38.          continue;
  39.       }
  40.       if(eval("\x01") == 396)
  41.       {
  42.          set("\x01",eval("\x01") + 371);
  43.          ┬º┬ºpush(true);
  44.          continue;
  45.       }
  46.       if(eval("\x01") == 991)
  47.       {
  48.          set("\x01",eval("\x01") - 775);
  49.          ┬º┬ºpush(true);
  50.          continue;
  51.       }
  52.       if(eval("\x01") == 419)
  53.       {
  54.          set("\x01",eval("\x01") + 334);
  55.          if(┬º┬ºpop())
  56.          {
  57.             set("\x01",eval("\x01") + 94);
  58.          }
  59.          continue;
  60.       }
  61.       if(eval("\x01") != 974)
  62.       {
  63.          if(eval("\x01") != 767)
  64.          {
  65.             if(eval("\x01") != 795)
  66.             {
  67.                if(eval("\x01") == 857)
  68.                {
  69.                   set("\x01",eval("\x01") + 38);
  70.                   ┬º┬ºpop() + getTimer();
  71.                }
  72.                if(eval("\x01") == 756)
  73.                {
  74.                   set("\x01",eval("\x01") + 218);
  75.                   break;
  76.                }
  77.                if(eval("\x01") == 88)
  78.                {
  79.                   set("\x01",eval("\x01") + 673);
  80.                   break;
  81.                }
  82.                if(eval("\x01") == 216)
  83.                {
  84.                   set("\x01",eval("\x01") + 540);
  85.                   if(┬º┬ºpop())
  86.                   {
  87.                      set("\x01",eval("\x01") + 218);
  88.                   }
  89.                   continue;
  90.                   if(!_global.MochiAd)
  91.                   {
  92.                      _global.MochiAd = _loc1_ = function()
  93.                      {
  94.                      };
  95.                      _loc2_ = _loc1_.prototype;
  96.                      ┬º┬ºgoto(addr996);
  97.                      ┬º┬ºpush(_loc1_);
  98.                      ┬º┬ºpush("showPreloaderAd");
  99.                   }
  100.                }
  101.                if(eval("\x01") == 970)
  102.                {
  103.                   set("\x01",eval("\x01") + 21);
  104.                   break;
  105.                }
  106.                if(eval("\x01") != 81)
  107.                {
  108.                   if(eval("\x01") != 800)
  109.                   {
  110.                      if(eval("\x01") == 753)
  111.                      {
  112.                         set("\x01",eval("\x01") + 94);
  113.                         loop1:
  114.                         while(true)
  115.                         {
  116.                            set(┬º┬ºpop(),eval("\x01") + 343);
  117.                            ┬º┬ºpush(true);
  118.                            while(true)
  119.                            {
  120.                               if(eval("\x01") == 587)
  121.                               {
  122.                                  set("\x01",eval("\x01") - 272);
  123.                                  ┬º┬ºpush(true);
  124.                                  continue;
  125.                               }
  126.                               if(eval("\x01") == 712)
  127.                               {
  128.                                  set("\x01",eval("\x01") - 179);
  129.                                  ┬º┬ºpush(┬º┬ºpop() == {});
  130.                                  break loop0;
  131.                               }
  132.                               if(eval("\x01") == 303)
  133.                               {
  134.                                  set("\x01",eval("\x01") - 75);
  135.                                  break loop0;
  136.                               }
  137.                               if(eval("\x01") == 348)
  138.                               {
  139.                                  set("\x01",eval("\x01") - 308);
  140.                                  break loop0;
  141.                               }
  142.                               if(eval("\x01") == 522)
  143.                               {
  144.                                  set("\x01",eval("\x01") + 439);
  145.                                  if(┬º┬ºpop())
  146.                                  {
  147.                                     set("\x01",eval("\x01") - 605);
  148.                                  }
  149.                                  continue;
  150.                               }
  151.                               if(eval("\x01") == 40)
  152.                               {
  153.                                  set("\x01",eval("\x01") + 742);
  154.                                  ┬º┬ºpush(true);
  155.                                  continue;
  156.                               }
  157.                               if(eval("\x01") == 370)
  158.                               {
  159.                                  break loop1;
  160.                               }
  161.                               if(eval("\x01") == 699)
  162.                               {
  163.                                  set("\x01",eval("\x01") - 351);
  164.                                  if(┬º┬ºpop())
  165.                                  {
  166.                                     set("\x01",eval("\x01") - 308);
  167.                                  }
  168.                                  continue;
  169.                               }
  170.                               if(eval("\x01") == 321)
  171.                               {
  172.                                  set("\x01",eval("\x01") + 210);
  173.                                  ┬º┬ºpush(true);
  174.                                  continue;
  175.                               }
  176.                               if(eval("\x01") == 102)
  177.                               {
  178.                                  set("\x01",eval("\x01") + 201);
  179.                                  if(┬º┬ºpop())
  180.                                  {
  181.                                     set("\x01",eval("\x01") - 75);
  182.                                  }
  183.                                  continue;
  184.                               }
  185.                               if(eval("\x01") == 306)
  186.                               {
  187.                                  set("\x01",eval("\x01") + 262);
  188.                                  if(┬º┬ºpop())
  189.                                  {
  190.                                     set("\x01",eval("\x01") - 89);
  191.                                  }
  192.                                  continue;
  193.                               }
  194.                               if(eval("\x01") == 825)
  195.                               {
  196.                                  set("\x01",eval("\x01") - 303);
  197.                                  ┬º┬ºpush(true);
  198.                                  continue;
  199.                               }
  200.                               if(eval("\x01") == 782)
  201.                               {
  202.                                  set("\x01",eval("\x01") - 412);
  203.                                  if(┬º┬ºpop())
  204.                                  {
  205.                                     set("\x01",eval("\x01") - 49);
  206.                                  }
  207.                                  continue;
  208.                               }
  209.                               if(eval("\x01") == 356)
  210.                               {
  211.                                  break;
  212.                               }
  213.                               if(eval("\x01") == 315)
  214.                               {
  215.                                  set("\x01",eval("\x01") + 397);
  216.                                  if(┬º┬ºpop())
  217.                                  {
  218.                                     set("\x01",eval("\x01") - 179);
  219.                                  }
  220.                                  continue;
  221.                               }
  222.                               if(eval("\x01") == 533)
  223.                               {
  224.                                  set("\x01",eval("\x01") - 75);
  225.                                  ┬º┬ºpush(true);
  226.                                  continue;
  227.                               }
  228.                               if(eval("\x01") == 961)
  229.                               {
  230.                                  set("\x01",eval("\x01") - 605);
  231.                                  break loop0;
  232.                               }
  233.                               if(eval("\x01") == 88)
  234.                               {
  235.                                  set("\x01",eval("\x01") + 728);
  236.                                  ┬º┬ºpush(┬º┬ºpop() & ┬º┬ºpop());
  237.                                  break loop0;
  238.                               }
  239.                               if(eval("\x01") == 531)
  240.                               {
  241.                                  set("\x01",eval("\x01") - 443);
  242.                                  if(┬º┬ºpop())
  243.                                  {
  244.                                     set("\x01",eval("\x01") + 728);
  245.                                  }
  246.                                  continue;
  247.                               }
  248.                               if(eval("\x01") == 458)
  249.                               {
  250.                                  set("\x01",eval("\x01") + 42);
  251.                                  if(┬º┬ºpop())
  252.                                  {
  253.                                     set("\x01",eval("\x01") + 249);
  254.                                  }
  255.                                  continue;
  256.                               }
  257.                               if(eval("\x01") != 500)
  258.                               {
  259.                                  if(eval("\x01") == 749)
  260.                                  {
  261.                                     set("\x01",eval("\x01") - 647);
  262.                                     ┬º┬ºpush(true);
  263.                                  }
  264.                                  else
  265.                                  {
  266.                                     if(eval("\x01") == 816)
  267.                                     {
  268.                                        set("\x01",eval("\x01") - 444);
  269.                                        stop();
  270.                                        break loop0;
  271.                                     }
  272.                                     if(eval("\x01") == 787)
  273.                                     {
  274.                                        set("\x01",eval("\x01") + 38);
  275.                                        break loop0;
  276.                                     }
  277.                                     if(eval("\x01") == 454)
  278.                                     {
  279.                                        set("\x01",eval("\x01") + 333);
  280.                                        if(┬º┬ºpop())
  281.                                        {
  282.                                           set("\x01",eval("\x01") + 38);
  283.                                        }
  284.                                     }
  285.                                     else if(eval("\x01") == 479)
  286.                                     {
  287.                                        set("\x01",eval("\x01") - 25);
  288.                                        ┬º┬ºpush(true);
  289.                                     }
  290.                                     else
  291.                                     {
  292.                                        if(eval("\x01") == 568)
  293.                                        {
  294.                                           set("\x01",eval("\x01") - 89);
  295.                                           break loop0;
  296.                                        }
  297.                                        if(eval("\x01") != 228)
  298.                                        {
  299.                                           if(eval("\x01") == 372)
  300.                                           {
  301.                                              set("\x01",eval("\x01") - 372);
  302.                                              break loop0;
  303.                                           }
  304.                                           break loop0;
  305.                                        }
  306.                                        set("\x01",eval("\x01") + 78);
  307.                                        ┬º┬ºpush(true);
  308.                                     }
  309.                                  }
  310.                                  continue;
  311.                               }
  312.                               set("\x01",eval("\x01") + 249);
  313.                               gotoAndStop(57014, mblength(┬º┬ºpop()));
  314.                               eval(┬º┬ºpop()).showing = false;
  315.                               chk.last_pcnt = 0;
  316.                               chk.fadeout_time = fadeout_time;
  317.                               chk.fadeFunction = function()
  318.                               {
  319.                                  var _loc2_ = 100 * (1 - (getTimer() - this.fadeout_start) / this.fadeout_time);
  320.                                  if(_loc2_ > 0)
  321.                                  {
  322.                                     this._parent._alpha = _loc2_;
  323.                                  }
  324.                                  else
  325.                                  {
  326.                                     var _loc3_ = this._parent._parent;
  327.                                     MochiAd.unload(_loc3_);
  328.                                     delete this.onEnterFrame;
  329.                                  }
  330.                               };
  331.                               mc.lc.adjustProgress = function(msec)
  332.                               {
  333.                                  var _loc2_ = this.mc._mochiad_wait;
  334.                                  _loc2_.server_control = true;
  335.                                  _loc2_.started = getTimer();
  336.                                  _loc2_.ad_msec = msec;
  337.                               };
  338.                               chk.onEnterFrame = function()
  339.                               {
  340.                                  var _loc6_ = this._parent._parent;
  341.                                  var _loc12_ = this._parent._mochiad_ctr;
  342.                                  var _loc5_ = getTimer() - this.started;
  343.                                  var _loc3_ = false;
  344.                                  var _loc4_ = _loc6_.getBytesTotal();
  345.                                  var _loc8_ = _loc6_.getBytesLoaded();
  346.                                  var _loc10_ = 100 * _loc8_ / _loc4_;
  347.                                  var _loc11_ = 100 * _loc5_ / chk.ad_msec;
  348.                                  var _loc9_ = this._mochiad_bar._inside;
  349.                                  var _loc2_ = Math.min(100,Math.min(_loc10_ || 0,_loc11_));
  350.                                  _loc2_ = Math.max(this.last_pcnt,_loc2_);
  351.                                  this.last_pcnt = _loc2_;
  352.                                  _loc9_._xscale = _loc2_;
  353.                                  if(!chk.showing)
  354.                                  {
  355.                                     var _loc7_ = _loc12_.getBytesTotal();
  356.                                     if(_loc7_ > 0 || typeof _loc7_ == "undefined")
  357.                                     {
  358.                                        chk.showing = true;
  359.                                        chk.started = getTimer();
  360.                                     }
  361.                                     else if(_loc5_ > chk.ad_timeout)
  362.                                     {
  363.                                        _loc3_ = true;
  364.                                     }
  365.                                  }
  366.                                  if(_loc5_ > chk.ad_msec)
  367.                                  {
  368.                                     _loc3_ = true;
  369.                                  }
  370.                                  if(_loc4_ > 0 && _loc8_ >= _loc4_ && _loc3_)
  371.                                  {
  372.                                     if(this.server_control)
  373.                                     {
  374.                                        delete this.onEnterFrame;
  375.                                     }
  376.                                     else
  377.                                     {
  378.                                        this.fadeout_start = getTimer();
  379.                                        this.onEnterFrame = chk.fadeFunction;
  380.                                     }
  381.                                  }
  382.                               };
  383.                               ┬º┬ºpop()[┬º┬ºpop()] = ┬º┬ºpop();
  384.                               _loc1_.showTimedAd = function(options)
  385.                               {
  386.                                  var _loc15_ = {clip:_root,ad_msec:11000,ad_timeout:2000,fadeout_time:250,regpt:"o",method:"showTimedAd"};
  387.                                  options = MochiAd._parseOptions(options,_loc15_);
  388.                                  var _loc6_ = options.clip;
  389.                                  var _loc12_ = options.ad_msec;
  390.                                  delete options.ad_msec;
  391.                                  var _loc14_ = options.ad_timeout;
  392.                                  delete options.ad_timeout;
  393.                                  var fadeout_time = options.fadeout_time;
  394.                                  delete options.fadeout_time;
  395.                                  if(!MochiAd.load(options))
  396.                                  {
  397.                                     return null;
  398.                                  }
  399.                                  _loc6_.stop();
  400.                                  var mc = _loc6_._mochiad;
  401.                                  mc.onUnload = function()
  402.                                  {
  403.                                     this._parent.play();
  404.                                  };
  405.                                  var _loc7_ = MochiAd._getRes(options);
  406.                                  var _loc16_ = _loc7_[0];
  407.                                  var _loc13_ = _loc7_[1];
  408.                                  mc._x = _loc16_ * 0.5;
  409.                                  mc._y = _loc13_ * 0.5;
  410.                                  var chk = mc.createEmptyMovieClip("_mochiad_wait",3);
  411.                                  chk.ad_msec = _loc12_;
  412.                                  chk.ad_timeout = _loc14_;
  413.                                  chk.started = getTimer();
  414.                                  chk.showing = false;
  415.                                  chk.fadeout_time = fadeout_time;
  416.                                  chk.fadeFunction = function()
  417.                                  {
  418.                                     var _loc2_ = 100 * (1 - (getTimer() - this.fadeout_start) / this.fadeout_time);
  419.                                     if(_loc2_ > 0)
  420.                                     {
  421.                                        this._parent._alpha = _loc2_;
  422.                                     }
  423.                                     else
  424.                                     {
  425.                                        var _loc3_ = this._parent._parent;
  426.                                        MochiAd.unload(_loc3_);
  427.                                        delete this.onEnterFrame;
  428.                                     }
  429.                                  };
  430.                                  mc.lc.adjustProgress = function(msec)
  431.                                  {
  432.                                     var _loc2_ = this.mc._mochiad_wait;
  433.                                     _loc2_.server_control = true;
  434.                                     _loc2_.started = getTimer();
  435.                                     _loc2_.ad_msec = msec - 250;
  436.                                  };
  437.                                  chk.onEnterFrame = function()
  438.                                  {
  439.                                     var _loc5_ = this._parent._mochiad_ctr;
  440.                                     var _loc4_ = getTimer() - this.started;
  441.                                     var _loc2_ = false;
  442.                                     if(!chk.showing)
  443.                                     {
  444.                                        var _loc3_ = _loc5_.getBytesTotal();
  445.                                        if(_loc3_ > 0 || typeof _loc3_ == "undefined")
  446.                                        {
  447.                                           chk.showing = true;
  448.                                           chk.started = getTimer();
  449.                                        }
  450.                                        else if(_loc4_ > chk.ad_timeout)
  451.                                        {
  452.                                           _loc2_ = true;
  453.                                        }
  454.                                     }
  455.                                     if(_loc4_ > chk.ad_msec)
  456.                                     {
  457.                                        _loc2_ = true;
  458.                                     }
  459.                                     if(_loc2_)
  460.                                     {
  461.                                        if(this.server_control)
  462.                                        {
  463.                                           delete this.onEnterFrame;
  464.                                        }
  465.                                        else
  466.                                        {
  467.                                           this.fadeout_start = getTimer();
  468.                                           this.onEnterFrame = this.fadeFunction;
  469.                                        }
  470.                                     }
  471.                                  };
  472.                               };
  473.                               _loc1_.load = function(options)
  474.                               {
  475.                                  var _loc14_ = {clip:_root,server:"http://x.mochiads.com/srv/1/",method:"load",depth:10333,id:"_UNKNOWN_"};
  476.                                  options = MochiAd._parseOptions(options,_loc14_);
  477.                                  options.swfv = options.clip.getSWFVersion() || 6;
  478.                                  options.mav = "1.3";
  479.                                  var _loc7_ = options.clip;
  480.                                  if(!MochiAd._isNetworkAvailable())
  481.                                  {
  482.                                     return false;
  483.                                  }
  484.                                  if(_loc7_._mochiad_loaded)
  485.                                  {
  486.                                     return false;
  487.                                  }
  488.                                  var _loc13_ = options.depth;
  489.                                  delete options.depth;
  490.                                  var _loc6_ = _loc7_.createEmptyMovieClip("_mochiad",_loc13_);
  491.                                  var _loc12_ = MochiAd._getRes(options);
  492.                                  options.res = _loc12_[0] + "x" + _loc12_[1];
  493.                                  options.server += options.id;
  494.                                  delete options.id;
  495.                                  _loc7_._mochiad_loaded = true;
  496.                                  var _loc4_ = _loc6_.createEmptyMovieClip("_mochiad_ctr",1);
  497.                                  for(var _loc8_ in options)
  498.                                  {
  499.                                     _loc4_[_loc8_] = options[_loc8_];
  500.                                  }
  501.                                  if(_loc7_._url.indexOf("http") != 0)
  502.                                  {
  503.                                     options.no_page = true;
  504.                                  }
  505.                                  var _loc11_ = _loc4_.server;
  506.                                  delete _loc4_.server;
  507.                                  var _loc10_ = _loc11_.split("/")[2].split(":")[0];
  508.                                  if(System.security)
  509.                                  {
  510.                                     if(System.security.allowDomain)
  511.                                     {
  512.                                        System.security.allowDomain("*");
  513.                                        System.security.allowDomain(_loc10_);
  514.                                     }
  515.                                     if(System.security.allowInsecureDomain)
  516.                                     {
  517.                                        System.security.allowInsecureDomain("*");
  518.                                        System.security.allowInsecureDomain(_loc10_);
  519.                                     }
  520.                                  }
  521.                                  _loc6_.onEnterFrame = function()
  522.                                  {
  523.                                     if(this._mochiad_ctr._url != this._url)
  524.                                     {
  525.                                        this.onEnterFrame = function()
  526.                                        {
  527.                                           if(!this._mochiad_ctr)
  528.                                           {
  529.                                              delete this.onEnterFrame;
  530.                                              MochiAd.unload(this._parent);
  531.                                           }
  532.                                        };
  533.                                     }
  534.                                  };
  535.                                  var _loc5_ = new LocalConnection();
  536.                                  var _loc9_ = ["",Math.floor(new Date().getTime()),random(999999)].join("_");
  537.                                  _loc5_.mc = _loc6_;
  538.                                  _loc5_.name = _loc9_;
  539.                                  _loc5_.hostname = _loc10_;
  540.                                  _loc5_.allowDomain = function(d)
  541.                                  {
  542.                                     return true;
  543.                                  };
  544.                                  _loc5_.allowInsecureDomain = _loc5_.allowDomain;
  545.                                  _loc5_.connect(_loc9_);
  546.                                  _loc6_.lc = _loc5_;
  547.                                  _loc4_.lc = _loc9_;
  548.                                  _loc4_.st = getTimer();
  549.                                  _loc4_.loadMovie(_loc11_ + ".swf","POST");
  550.                                  return _loc6_;
  551.                               };
  552.                               _loc1_.unload = function(clip)
  553.                               {
  554.                                  if(typeof clip == "undefined")
  555.                                  {
  556.                                     clip = _root;
  557.                                  }
  558.                                  if(clip.clip && clip.clip._mochiad)
  559.                                  {
  560.                                     clip = clip.clip;
  561.                                  }
  562.                                  if(!clip._mochiad)
  563.                                  {
  564.                                     return false;
  565.                                  }
  566.                                  clip._mochiad.removeMovieClip();
  567.                                  delete clip._mochiad_loaded;
  568.                                  delete clip._mochiad;
  569.                                  return true;
  570.                               };
  571.                               _loc1_._isNetworkAvailable = function()
  572.                               {
  573.                                  if(System.security)
  574.                                  {
  575.                                     var _loc1_ = System.security;
  576.                                     if(_loc1_.sandboxType == "localWithFile")
  577.                                     {
  578.                                        return false;
  579.                                     }
  580.                                  }
  581.                                  return true;
  582.                               };
  583.                               _loc1_._getRes = function(options)
  584.                               {
  585.                                  var _loc3_ = options.clip.getBounds();
  586.                                  var _loc2_ = 0;
  587.                                  var _loc1_ = 0;
  588.                                  if(typeof options.res != "undefined")
  589.                                  {
  590.                                     var _loc4_ = options.res.split("x");
  591.                                     _loc2_ = parseFloat(_loc4_[0]);
  592.                                     _loc1_ = parseFloat(_loc4_[1]);
  593.                                  }
  594.                                  else
  595.                                  {
  596.                                     _loc2_ = _loc3_.xMax - _loc3_[┬º┬ºconstant(101)];
  597.                                     _loc1_ = _loc3_[┬º┬ºconstant(102)] - _loc3_[┬º┬ºconstant(103)];
  598.                                  }
  599.                                  if(_loc2_ == 0 || _loc1_ == 0)
  600.                                  {
  601.                                     _loc2_ = eval(┬º┬ºconstant(104))[┬º┬ºconstant(105)];
  602.                                     _loc1_ = eval(┬º┬ºconstant(104))[┬º┬ºconstant(106)];
  603.                                  }
  604.                                  return [_loc2_,_loc1_];
  605.                               };
  606.                               _loc1_._parseOptions = function(options, defaults)
  607.                               {
  608.                                  var _loc4_ = {};
  609.                                  for(var _loc8_ in defaults)
  610.                                  {
  611.                                     _loc4_[_loc8_] = defaults[_loc8_];
  612.                                  }
  613.                                  if(options)
  614.                                  {
  615.                                     for(_loc8_ in options)
  616.                                     {
  617.                                        _loc4_[_loc8_] = options[_loc8_];
  618.                                     }
  619.                                  }
  620.                                  if(_root.mochiad_options)
  621.                                  {
  622.                                     var _loc5_ = _root.mochiad_options.split("&");
  623.                                     var _loc2_ = 0;
  624.                                     while(_loc2_ < _loc5_.length)
  625.                                     {
  626.                                        var _loc3_ = _loc5_[_loc2_].split("=");
  627.                                        _loc4_[unescape(_loc3_[0])] = unescape(_loc3_[1]);
  628.                                        _loc2_ = _loc2_ + 1;
  629.                                     }
  630.                                  }
  631.                                  return _loc4_;
  632.                               };
  633.                               ┬º┬ºpush(ASSetPropFlags(_global.MochiAd.prototype,null,1));
  634.                            }
  635.                         }
  636.                         set("\x01",eval("\x01") - 49);
  637.                         break;
  638.                      }
  639.                      if(eval("\x01") != 405)
  640.                      {
  641.                         if(eval("\x01") == 797)
  642.                         {
  643.                            set("\x01",eval("\x01") - 392);
  644.                            ┬º┬ºpush(true);
  645.                            continue;
  646.                         }
  647.                         if(eval("\x01") == 177)
  648.                         {
  649.                            set("\x01",eval("\x01") + 219);
  650.                            var _loc2_ = ┬º┬ºpop()[┬º┬ºpop() >> ┬º┬ºpop() * ┬º┬ºpop()] - _loc3_[┬º┬ºconstant(101)];
  651.                            var _loc1_ = _loc3_[┬º┬ºconstant(102)] - _loc3_[┬º┬ºconstant(103)];
  652.                            if(_loc2_ == 0 || _loc1_ == 0)
  653.                            {
  654.                               _loc2_ = eval(┬º┬ºconstant(104))[┬º┬ºconstant(105)];
  655.                               _loc1_ = eval(┬º┬ºconstant(104))[┬º┬ºconstant(106)];
  656.                            }
  657.                            return [_loc2_,_loc1_];
  658.                         }
  659.                         if(eval("\x01") == 734)
  660.                         {
  661.                            set("\x01",eval("\x01") + 63);
  662.                            ifFrameLoaded(┬º┬ºpop())
  663.                            {
  664.                            }
  665.                         }
  666.                         if(eval("\x01") == 761)
  667.                         {
  668.                            set("\x01",eval("\x01") - 357);
  669.                            ┬º┬ºpush(true);
  670.                            continue;
  671.                         }
  672.                         if(eval("\x01") == 823)
  673.                         {
  674.                            set("\x01",eval("\x01") - 89);
  675.                            if(┬º┬ºpop())
  676.                            {
  677.                               set("\x01",eval("\x01") + 63);
  678.                            }
  679.                            continue;
  680.                         }
  681.                         if(eval("\x01") == 805)
  682.                         {
  683.                            set("\x01",eval("\x01") - 386);
  684.                            ┬º┬ºpush(true);
  685.                            continue;
  686.                         }
  687.                      }
  688.                      set("\x01",eval("\x01") + 565);
  689.                      if(┬º┬ºpop())
  690.                      {
  691.                         set("\x01",eval("\x01") + 21);
  692.                      }
  693.                      continue;
  694.                      if(eval("\x01") != 847)
  695.                      {
  696.                         if(eval("\x01") == 358)
  697.                         {
  698.                            set("\x01",eval("\x01") - 358);
  699.                            break;
  700.                         }
  701.                         break;
  702.                      }
  703.                   }
  704.                   set("\x01",eval("\x01") - 5);
  705.                   ┬º┬ºpush(true);
  706.                   continue;
  707.                   set("\x01",eval("\x01") - 489);
  708.                }
  709.             }
  710.             set("\x01",eval("\x01") + 58);
  711.             if(┬º┬ºpop())
  712.             {
  713.                set("\x01",eval("\x01") - 48);
  714.             }
  715.             continue;
  716.             set("\x01",eval("\x01") + 859);
  717.          }
  718.          set("\x01",eval("\x01") - 679);
  719.          if(┬º┬ºpop())
  720.          {
  721.             set("\x01",eval("\x01") + 673);
  722.          }
  723.          continue;
  724.          if(┬º┬ºpop())
  725.          {
  726.             set("\x01",eval("\x01") - 140);
  727.          }
  728.       }
  729.    }
  730.    set("\x01",eval("\x01") + 88);
  731.    if(┬º┬ºpop())
  732.    {
  733.       set("\x01",eval("\x01") + 219);
  734.    }
  735.    continue;
  736.    continue;
  737.    continue;
  738.    ┬º┬ºpop();
  739.    break;
  740. }
  741.